#include "Barde.h"

//#include <boost/assign/list_of.hpp>

using namespace std;
using namespace boost::assign;

/*
  Une fois le Voleur OK, recopier ici les ajustements pour le Barde
 */

/**
 * Contient les valeurs de base des talents de barde. Un '100' signifie que
 * La compétence n'est pas associée à un pourcentage.
 */
const vector<unsigned int> Barde::comp_base = list_of
  (100)(100)(100)(20)(10)(50)(100)(100)(5)
  (100)(100)(100)(100)(100)(100)(100)(10);

const unsigned int Barde::nbr_comp = 17;

const unsigned int Barde::nbr_restric = 0;

const vector<ListComp> Barde::Comp = list_of
  (ListComp("Amitié avec les animaux"           , 10, false))
  (ListComp("Barde en armure"                   , 10, false))
  (ListComp("Contre-chant"                      , 10, false))
  (ListComp("Détecter des bruits"               ,  5, true)) // base = 20%
  (ListComp("Détection de la magie"             , 10, true)) // base = 10%
  (ListComp("Grimper"                           ,  5, true)) // base = 50%
  (ListComp("Histoire"                          , 10, false))
  (ListComp("Inspiration"                       ,  5, false))
  (ListComp("Lire des langues inconnues"        ,  5, true)) // base = 5%
  (ListComp("Manipulation"                      ,  5, false))
  (ListComp("Résistance aux charmes"            ,  5, false))
  (ListComp("Résistance aux sons"               ,  5, false))
  (ListComp("Sorts de mage"                     , 10, false))
  (ListComp("Spécialisation"                    , 10, false))
  (ListComp("Utilisation de parchemins (niv 10)",  5, false))
  (ListComp("Utilisation de parchemins"         , 10, false))
  (ListComp("Vol à la tire"                     , 10, true));  // base = 10%

/** Constructeur usuel.
 * Permet la construction d'un barde de A à Z, càd on détermine ici
 * les restrictions, puis les compétences.
 * @param xp le nombre de pts d'expérience du Barde.
 * @param trait les traits du Barde, le 7ème contient le score de
 * force exceptionnel, fixé à 0 si non applicable.
 * @param PP nombre de points de personnage (PP) à disposition pour la
 * céation du Barde.
 */
Barde::Barde(unsigned int xp, unsigned int trait[7], unsigned int& PP)
  : Classe(xp, trait, Roublards)
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(elementaire);
  Type_classe = "Barde";
  ptrComp    = &Comp;
  ptrValBase = &comp_base;
  ptrNbrComp = &nbr_comp;
  ptrNbrRes  = &nbr_restric;
  PP += 70;
  blank() << setfill('*') << setw(56) << '*' << setfill(' ') << endreq;
  blank() << "Création d'un barde" << endreq << endreq;
  unsigned int nbr(0);

  blank() << "Tu as " << PP << " pp à dépenser" << endreq;

  for (unsigned int i(0); i < nbr_comp; i++)
    blank() << i+1 << ' ' << (Comp[i].Comp)
		<< " (" << Comp[i].Cout << " pp)" << endreq;	
  blank() << nbr_comp+1 << " Aucune" << endreq;
  blank() << "Choisir les compétences de classe" << endreq;

  bool test(true), deja_pris, encore(false);
  unsigned int save_PP(PP);
  vector<unsigned int> oublier;

  do
    {
      do
	{
	  nbr = demander_unsigned_borne("("+write_int(PP)+" PP restants) ", 1,
					nbr_comp + 1);
	  
	  if (nbr!=nbr_comp+1)
	    {
	      if (PP >= Comp[nbr-1].Cout)
		{
		  deja_pris = safe_push_back(&Comp_classe, nbr - 1, oublier);
		  if (deja_pris)	     
		    warning() << "Déjà sélectionné" << endreq;
		  else
		    {
		      Comp_classe.push_back(nbr-1);
		      PP -= Comp[nbr-1].Cout;
		      blank() << "Compétence choisie : "
				  << (Comp[nbr-1].Comp) << endreq;
		      if (Comp[nbr-1].Pourcentage)
			{
			  oublier.push_back(Comp_classe.size());
			  debug() << "oublier " << oublier.back() << endreq;
			  Comp_classe.push_back(comp_base[nbr-1]);
			  debug() << nbr-1 << " => " << Comp[nbr-1].Comp
				      << " " << comp_base[nbr-1] << endreq;
			}
		      else
			debug() << nbr-1 << " => " << Comp[nbr-1].Comp << endreq;
		    }
		}
	      else
		blank() << "Pas assez de pp" << endreq;
	    }
	  else
	    test = false;
	}
      while(test);

      affiche_competences();
      blank() << endl <<  "1 pour continuer, 2 pour recommencer" << endreq;
      nbr = demander_unsigned_borne("Choix ", 1, 2);
      if (nbr == 2)
	{
	  PP = save_PP;
	  Comp_classe.clear();
	  test = true;
	  encore = true;
	  blank() << endreq;
	}
      else
	encore = false;
    }
  while(encore);


  for(unsigned int k(0); k < Comp_classe.size(); k++)
    debug() << Comp_classe[k] << ' ';
  debug() << endreq;
  blank() << endl << setfill('*') << setw(56) << '*' << setfill(' ')
	      << endreq;
 calcul_niveau();
 calcul_niv_mag();

 augmenter_talents(20, false);
 dout.setLevel(etat_precedent);
}

/** Constructeur simplifié.
 * Permet de construire un Barde lors de la lecture d'un ficier xml.
 * @param xp le nombre de pts d'expérience du Barde.
 * @param trait les traits du Barde, le 7ème contient le score de
 * force exceptionnel, fixé à 0 si non applicable.
 */
Barde::Barde(unsigned int xp, unsigned int trait[7])
  : Classe(xp, trait, Roublards)
{
  Type_classe = "Barde";
  ptrComp    = &Comp;
  ptrValBase = &comp_base;
  ptrNbrComp = &nbr_comp;
  ptrNbrRes  = &nbr_restric;
  calcul_niveau();
  calcul_niv_mag();
}

Barde::Barde(unsigned int xp, unsigned int trait[7], const bool& UI)
  : Classe(xp, trait, Roublards)
{
  if (!UI)
    {
      error() << "Création du personnage impossible" << endreq;
      exit(1);
    }

  Type_classe = "Barde";
  ptrComp    = &Comp;
  ptrValBase = &comp_base;
  ptrNbrComp = &nbr_comp;
  ptrNbrRes  = &nbr_restric;
  calcul_niveau();
  calcul_niv_mag();
}

Barde::~Barde()
{}

void Barde::calcul_niveau()
{
  if (XP < 75000)
    {
      unsigned int i;
      for (i = 0; i < 5; i++)
	{
	  if (XP < (unsigned int) 1250 * puissance(2, i))
	    break;
	}
      Niveau = i + 1;
    }
  else if (XP < 70000)
    Niveau = 7;
  else if (XP < 110000)
    Niveau = 8;
  else if (XP < 160000)
    Niveau = 9;
  else if (XP < 220000)
    Niveau = 10;
  else
      Niveau = (XP - 220000) / 220000 + 11;
}

// /**
//  * Ici il faut faire attention aux pourcentages.
//  */
// void Barde::afficher_stats(ostream& os)
// {
//   os << "Barde" << endreq;
//   for (unsigned int i(0); i<6; i++)
//     os << Caracteristiques[i] << ' ' << Traits[i] << endreq;
//   for (unsigned int i(0); i<Comp_classe.size(); i++)
//     {
//       debug() << Comp_classe[i] << endreq;
//       if(Comp[Comp_classe[i]].Pourcentage)
// 	{
// 	  os << (Comp[Comp_classe[i]].Comp)
// 		      << ' ' << Comp_classe[i+1] << '%' << endreq;
// 	  i++;
// 	}
//       else
// 	os << (Comp[Comp_classe[i]].Comp)
// 		    << endreq;
//     }
// }

/**
 * Ici sont appliqués les modifications aux talents de barde dues à la Race
 * et à la Dextérité.
 *
 * Et il parait qu'il faut tout revoir... :\@
 * @param type nom de la race
 */
void Barde::appliquer_modif(const string& type)
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  vector<unsigned int> comp_bonus(17, 0);

   if (type == "Nain")
    {
      comp_bonus[5]  -= 10;  // escalade
      comp_bonus[8]  -= 5;   // lire des langues inconnues
      comp_bonus[4]  += 5;   // détection de la magie
    }
  else if (type == "Elfe")
    {
      comp_bonus[16] += 5;   // vol à la tire
      comp_bonus[3]  += 5;   // détection des bruits
      comp_bonus[4]  += 10;  // détection de la magie
    }
  else if (type == "Gnome")
    {
      comp_bonus[3]  += 10;  // détection des bruits
      comp_bonus[5]  -= 15;  // escalade
      comp_bonus[4]  += 5;   // détection de la magie
    }
  else if (type == "Demi-Elfe")
    {
      comp_bonus[16] += 10;  // vol à la tire
      comp_bonus[4]  += 5;   // détection de la magie
    }
  else if (type == "Demi-Orque")
    {
      comp_bonus[3]  += 5;   // détection des bruits
    }
  else if (type == "Hobbit")
    {
      comp_bonus[16] += 5;   // vol à la tire
      comp_bonus[3]  += 10;  // détection des bruits
      comp_bonus[5]  -= 15;  // escalade
      comp_bonus[8]  -= 5;   // lire des langues inconnues
      comp_bonus[4]  += 5;   // détection de la magie
    }

  switch(Traits[1])
    {
    case 9:
      comp_bonus[16] -= 15;  // vol à la tire
      comp_bonus[5]  -= 10;  // escalade
      break;
    case 10:
      comp_bonus[16] -= 10;  // vol à la tire
      comp_bonus[5]  -= 5;   // escalade
      break;
    case 11:
      comp_bonus[16] -= 5;   // vol à la tire
      break;
    case 17:
      comp_bonus[16] += 5;   // vol à la tire
      comp_bonus[5]  += 5;   // escalade
      break;
    case 18:
      comp_bonus[16] += 10;  // vol à la tire
      comp_bonus[5]  += 10;  // escalade
      break;
    case 19:
      comp_bonus[16] += 15;  // vol à la tire
      comp_bonus[5]  += 15;  // escalade
      break;
    case 20:
      comp_bonus[16] += 20;  // vol à la tire
      comp_bonus[5]  += 20;  // escalade
      break;
    case 21:
      comp_bonus[16] += 20;  // vol à la tire
      comp_bonus[5]  += 20;  // escalade
      break;
    case 22:
      comp_bonus[16] += 25;  // vol à la tire
      comp_bonus[5]  += 25;  // escalade
      break;
    }

  unsigned int combien_comp(Comp_classe.size()), valeur;
  vector<unsigned int> tmp;
  for (unsigned int i(0); i< combien_comp; i++)
    {
      valeur = Comp_classe[i];
      if (Comp[valeur].Pourcentage)
	{
	  Comp_classe[i + 1] += comp_bonus[valeur];
	  i++;
	}
    }

  dout.setLevel(etat_precedent);
}

/**
 * Ici on peut augmenter les talents liés à un pourcentage à chaque passage
 * de niveau et à la création.
 *
 * Une sauvegarde de l'état courant est faite avant de modifier quoi que ce
 * soit, et ensuite on afiche un récapitulatif des changements, qui doivent
 * être validés.
 */
void Barde::augmenter_talents(const unsigned int& bonus, const bool& lvl_up)
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  vector<unsigned int> quelle, combien[2];
  unsigned int taille(get_combien()), nbr(0), depense, laquelle, encore, i,
    j(0);
  
  for (unsigned int i(0); i<taille; i++)
    {
      debug() << Comp_classe[i];
      if (Comp[Comp_classe[i]].Pourcentage)
	{
	  debug() << " -> oui";
	  quelle.push_back(Comp_classe[i]);
	  combien[0].push_back(Comp_classe[i+1]);
	  combien[1].push_back(Comp_classe[i+1]);
	  i++;
	  nbr++;
	}
      debug() << endreq;
    }
  do
    {
      unsigned int pps(bonus);
      if (lvl_up)
	pps = 15;
      blank() << "Tu as " << pps << " point à dépenser dans les compétences"
		  << " suivantes:" << endreq;
      for (i = 0; i<nbr; i++)
	{
	  debug() << quelle[i] << " => " << Comp[quelle[i]].Comp << endreq;
	  blank() << i+1 << " " << Comp[quelle[i]].Comp << " "
		      << combien[0][i] << "%" << endreq;
	}
      
      string poubelle;
      
      while(pps != 0)
	{
	  
	  laquelle =
	    demander_unsigned_borne("Quelle compétence veux-tu améliorer? ",
				    1, nbr);
	  
	  depense = demander_unsigned_borne("De combien? ", 0, pps);
	  
	  combien[1][laquelle-1] += depense;
	  pps -= depense;
	}
      
      for (i = 0; i < nbr; i++)
	{
	  blank() << Comp[quelle[i]].Comp << " "
		      << combien[0][i] << " -> " << combien[1][i]
		      << endreq;
	}
      blank() << endl <<  "1 pour continuer, 2 pour recommencer" << endreq;
      encore = demander_unsigned_borne("Choix ", 1, 2);
    }
  while (encore == 2);

  j = 0;
  
  for (i = 0; i < taille; i++)
    {
      if (Comp_classe[i] == quelle[j])
	{
	  debug() << Comp[quelle[j]].Comp << " "
		      << combien[0][j] << " -> " << combien[1][j]
		      << endreq;
	  lfunc() << get_competence(i) << " -> ";
	  Comp_classe[i + 1] = combien[1][j];
	  lfunc() << get_competence(i) << endreq;
	  j++;
	}
    }

  dout.setLevel(etat_precedent);
}

void Barde::get_JS(unsigned int *tab) const
{
  *(tab + 0) = 13; // Paralysie, Poison ou Mort magique
  *(tab + 1) = 14; // Bâton, batonnet baguette
  *(tab + 2) = 12; // Pétrification ou Métamorphose
  *(tab + 3) = 16; // Souffles
  *(tab + 4) = 15; // Sorts
  
  unsigned int cat;
  if (Niveau <= 4)
    cat = 0;
  else  if (Niveau <= 8)
    cat = 1;
  else  if (Niveau <= 12)
    cat = 2;
  else  if (Niveau <= 16)
    cat = 3;
  else  if (Niveau <= 20)
    cat = 4;
  else
    cat = 5;

  *(tab + 0) -= cat;
  *(tab + 1) -= 2 * cat;
  *(tab + 2) -= cat;
  *(tab + 3) -= cat;
  *(tab + 4) -= 2 * cat;
}

string Barde::get_competence(const unsigned int& i) const
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  debug() << "Compétence numéro " << i << endreq;
  if (Comp[get_comp(i)].Pourcentage)
    {
      dout.setLevel(etat_precedent);
      return " " + Comp[get_comp(i)].Comp + " " + write_int(get_comp(i+1)) + "\\%";
    }
  else
    {
      dout.setLevel(etat_precedent);
      return Comp[get_comp(i)].Comp;
    }
}

unsigned int Barde::calcule_TAc0() const
{
  unsigned int mod_niveau((Niveau - 1) / 2);

  return 20 - mod_niveau;
}

void Barde::calcul_niv_mag()
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  func() << "Barde::calcul_niv_mag -> début" << endreq;
  bool a_des_sorts(false);

  vector<unsigned int>::const_iterator it, Begin(Comp_classe.begin()),
    End(Comp_classe.end());

  it = find(Begin, End, 12);

  if (it != End)
    {
      a_des_sorts = true;
      debug() << "A accès aux sorts de mages" << endreq;
    }

  if (a_des_sorts)
    {
      if (Niveau < 4)
	Niveau_mag = (Niveau) / 2;
      else if (Niveau < 19)
	Niveau_mag = (Niveau + 2) / 3;
      else
	Niveau_mag = 6;  
    }
  else
    Niveau_mag = 0;

  
  func() << "Barde::calcul_niv_mag -> fin" << endreq;
  dout.setLevel(etat_precedent);
}

/**
 * Il faut ici regarder dans Cl_sorts pour savoir quels sont les sorts
 * contenus dans le Livre de Sorts du magicien.
 * 
 * Le tri se fait d'abord par Ecole, puis par Niveau et ensuite dans l'ordre
 * alphabétique.
 *
 * La variable Classe::fonction permet d'afficher :
 *
 * FUNC  : début et fin de l'exécution de la méthode
 *
 * DEBUG : écrasement du fichier, nombre de sorts, sort courant
 */
void Barde::ecrire_sorts(const string& nom_fichier, const bool& ecrase) const
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  func() << "Barde::ecrire_sorts -> début" << endreq;

  ofstream sortie;
  if (ecrase)
    {
      debug() << "Ecrasement du fichier " << nom_fichier << endreq;
      sortie.open(nom_fichier.c_str());
    }
  else
    {
      sortie.open(nom_fichier.c_str(), ios::app);
      sortie << "\\newpage" << endreq;
    }

  if (Niveau_mag == 0)
    return;

  sortie << "\\section*{Livre de sorts - Barde}" << endl;

  unsigned int *vec = new unsigned int[Niveau_mag];

  nbr_sort(vec, Niveau_mag);
  
  sortie << "\\begin{center}" << endl 
	 << "\\begin{tabular*}{10cm}{@{\\extracolsep{\\fill}} l r}"
	 << endl << "\\multicolumn{2}{c}{Nombre de sorts par jour} \\\\"
	 << "\\hline \\\\ \\vspace{1mm}" << endl;
  for (unsigned int i(0); i < Niveau_mag; i++)
    sortie << "Niveau " << i+1 << " & " << vec[i] << " \\\\" << endl;
  sortie << "\\end{tabular*}" << endl << "\\end{center}" << endl;

  unsigned int taille(get_combien_sorts()), i, courant(10), niv_courant(10);
  string nom_ecoles[8] = {
    "Abjuration", "Alt\\'eration", "Conjuration\\ -\\ Convocation",
    "Divination",
    "Enchantement\\ -\\ Charme", "Illusion", "Invocation\\ -\\ Evocation",
    "N\'ecromancie"};

  debug() << "nbr de sorts = " << taille << endreq;

  for(i = 0; i < taille; i++)
    {
      if (Cl_sorts[i].get_Ecole() != courant)
	{
	  courant = Cl_sorts[i].get_Ecole();
	  sortie << "\\subsection*{" << affiche_accent(nom_ecoles[courant])
		 << "}" << endl;
	}
      if (Cl_sorts[i].get_Niveau() != niv_courant)
	{
	  niv_courant = Cl_sorts[i].get_Niveau();
	  sortie << "\\subsubsection*{Niveau " << niv_courant << "}" << endl;
	}

      sortie << "\\input{../../Sorts-mage/"
	     << supprime_accents(nom_ecoles[courant]) << "/sort_" << niv_courant
	     << "_" << Cl_sorts[i].get_Numero()<< ".inc.tex}" << endl;
    }

  sortie.close();


  func() << "Barde::ecrire_sorts -> fin" << endreq;
  dout.setLevel(etat_precedent);
}

void Barde::nbr_sort(unsigned int sorts[], const unsigned int& taille) const
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  func() << "Barde::nbr_sort -> début" << endreq;
  unsigned int i;
  unsigned int tmp[7];
  func() << "Taille = " << taille << endreq;

  for (i = 0; i < taille; i++)
    tmp[i] = 0;

  switch(Niveau)
    {
    case 2:
      tmp[0] = 1;
      break;
    case 3:
      tmp[0] = 2;
      break;
    case 4:
      tmp[0] = 2;
      tmp[1] = 1;
      break;
    case 5:
      tmp[0] = 3;
      tmp[1] = 1;
      break;
    case 6:
      tmp[0] = 3;
      tmp[1] = 2;
      break;
    case 7:
      tmp[0] = 3;
      tmp[1] = 2;
      tmp[2] = 1;
      break;
    case 8:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 1;
      break;
    case 9:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 2;
      break;
    case 10:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 2;
      tmp[3] = 1;
      break;
    case 11:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 1;
      break;
    case 12:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 2;
      break;
    case 13:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 2;
      tmp[4] = 1;
      break;
    case 14:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 3;
      tmp[4] = 1;
      break;
    case 15:
      tmp[0] = 3;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 3;
      tmp[4] = 2;
      break;
    case 16:
      tmp[0] = 4;
      tmp[1] = 3;
      tmp[2] = 3;
      tmp[3] = 3;
      tmp[4] = 2;
      tmp[5] = 1;
      break;
    case 17:
      tmp[0] = 4;
      tmp[1] = 4;
      tmp[2] = 3;
      tmp[3] = 3;
      tmp[4] = 3;
      tmp[5] = 1;
      break;
    case 18:
      tmp[0] = 4;
      tmp[1] = 4;
      tmp[2] = 4;
      tmp[3] = 3;
      tmp[4] = 3;
      tmp[5] = 2;
      break;
    case 19:
      tmp[0] = 4;
      tmp[1] = 4;
      tmp[2] = 4;
      tmp[3] = 4;
      tmp[4] = 3;
      tmp[5] = 2;
      break;
    default:
      tmp[0] = 4;
      tmp[1] = 4;
      tmp[2] = 4;
      tmp[3] = 4;
      tmp[4] = 4;
      tmp[5] = 3;
      break;
    }

  for (i = 0; i < Niveau_mag; i++)
    sorts[i] = tmp[i];

  func() << "Barde::nbr_sort -> fin" << endreq;
  dout.setLevel(etat_precedent);
}

/**
 *
 * Permet de gérer l'ajout de sorts au livre du magicien
 *
 * La variable Classe::fonction permet d'afficher
 *
 * FUNC  : les messages de début - fin de la méthode
 *
 * LFUNC : les écoles auxquelles le Barde a accès
 *
 * DEBUG : numéro du dernier sort, sort écrit, sorts triés
 */
void Barde::ajout_sorts()
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  func() << "Barde::ajout_sorts -> début" << endreq;
  
  unsigned int nbr, dernier, i;
  string ecole;

  if (Niveau_mag == 0)
    {
      debug() << "Niveau magique = 0" << endreq;
      return;
    }
  for (i = 0; i < 8; i++)
    {
      for (unsigned int j(1); j <= Niveau_mag; j++)
	{
	  blank() << "Niveau " << j << " :" << endreq;
	  dernier = affiche_sorts(i, j);
	  
	  debug() << "dernier = " << dernier << endreq;
	  
	  if (dernier > 0)
	    {
	      blank() << setw(2) << dernier + 1 << " Aucun" << endreq;
	      do
		{
		  nbr = demander_unsigned_borne("Entrer nouveau sort : ", 1,
						dernier + 1);
		  if (nbr != dernier + 1)
		    {
		      debug() << "Ajout du sort " << Sort(i, j, nbr - 1)
				      << endreq;
		      Cl_sorts.push_back(Sort(i, j, nbr - 1));
		    }
		}
	      while(nbr != dernier + 1);
	    }
	}
    }
  
  vector<Sort>::iterator Begin, End, it;
  Begin = Cl_sorts.begin();
  End   = Cl_sorts.end();
  
  for (i = 0; i < Cl_sorts.size(); i++)
    debug() << Cl_sorts[i] << endreq;
  
  debug() << "Tri effectué" << endreq;
  
  sort(Begin, End);
  
  for (it = ++Begin; it != End; it++)
    {
      if (*it == *(it - 1))
	{
	  lfunc() << "Même sort!" << endreq;
	  Cl_sorts.erase(it);	  
	}
    }
    
  
  for (i = 0; i < Cl_sorts.size(); i++)
    debug() << Cl_sorts[i] << endreq;
  
  func() << "Barde::ajout_sorts -> fin" << endreq;
  dout.setLevel(etat_precedent);
}

/**
 * Permet de gérer les compétences martiales, càd lesquelles sont accessibles
 * à quel coût.
 *
 * Un Barde peut prendre n'importe quelle arme pour 3 pp.
 */
void Barde::get_prix_acces(map<string, unsigned int>* Map) const
{
  DebugLevelType etat_precedent(dout.getLevel());
  dout.setLevel(fonction);
  func() << "Barde::get_prix_acces -> début" << endreq;

  map<string, unsigned int>::const_iterator mapIt, mapBegin(Map -> begin()),
    mapEnd(Map -> end());

  for (mapIt = mapBegin; mapIt != mapEnd; mapIt++)
    {
      lfunc() << mapIt -> first << endreq;
    }
  Map -> operator[]("Barde") = 3;
  
  func() << "Barde::ajout_sorts -> fin" << endreq;
  dout.setLevel(etat_precedent);
}
